import axios from 'axios'
import { getCookie } from '../utils/cookie.js'

// 创建axios实例
const api = axios.create({
  baseURL: 'http://localhost:8002/api',
  timeout: 30000, // 增加超时时间以支持流式响应
  headers: {
    'Content-Type': 'application/json'
  }
})

// 请求拦截器 - 添加token
api.interceptors.request.use(
  config => {
    console.log('🚀 [API] 发送请求:', {
      method: config.method?.toUpperCase(),
      url: config.url,
      baseURL: config.baseURL,
      data: config.data,
      params: config.params
    })
    
    // 自动添加认证头 - 优先从 Pinia store 获取，然后从 Cookie
    let token = null

    // 尝试从 Pinia store 获取 token
    try {
      const piniaUserData = localStorage.getItem('pinia-user')
      if (piniaUserData) {
        const userData = JSON.parse(piniaUserData)
        token = userData.token
        console.log('🔑 [API] 从Pinia获取Token')
      }
    } catch (error) {
      console.log('⚠️ [API] Pinia Token获取失败，尝试Cookie')
    }

    // 如果 Pinia 中没有，尝试从 Cookie 获取
    if (!token) {
      token = getCookie('token')
      if (token) {
        console.log('🔑 [API] 从Cookie获取Token')
      }
    }

    if (token) {
      config.headers.Authorization = `Bearer ${token}`
      console.log('✅ [API] 已添加认证Token')
    } else {
      console.log('⚠️ [API] 未找到认证Token')
    }
    return config
  },
  error => {
    console.error('💥 [API] 请求拦截器错误:', error)
    return Promise.reject(error)
  }
)

// 响应拦截器 - 统一处理响应
api.interceptors.response.use(
  response => {
    console.log('✅ [API] 响应成功:', {
      status: response.status,
      statusText: response.statusText,
      url: response.config.url,
      data: response.data
    })
    // 统一包装成功响应格式
    return {
      success: true,
      data: response.data,
      message: 'success'
    }
  },
  error => {
    console.error('❌ [API] 响应错误:', {
      status: error.response?.status,
      statusText: error.response?.statusText,
      url: error.config?.url,
      message: error.message,
      data: error.response?.data
    })
    
    if (error.response) {
      // 服务器返回错误状态码
      const { status, data } = error.response
      
      if (status === 401) {
        console.log('🔒 [API] Token过期，清除登录状态')
        // token过期或无效，使用 Pinia 清除登录状态
        // 注意：这里不能直接导入 store，因为会造成循环依赖
        // 我们通过事件或者在组件中处理401错误
        localStorage.removeItem('pinia-user')
        window.location.reload()
      }
      
      return Promise.reject({
        success: false,
        message: data.detail || data.message || '请求失败',
        status
      })
    } else if (error.request) {
      // 网络错误
      return Promise.reject({
        success: false,
        message: '网络连接失败，请检查网络设置'
      })
    } else {
      // 其他错误
      return Promise.reject({
        success: false,
        message: error.message || '未知错误'
      })
    }
  }
)

// 🔥 标准 SSE 流式处理函数 - 完美支持 data: {...json...} 格式
const handleStreamResponse = async (response, onMessage, onComplete, onError) => {
  console.log('🚀 [SSE] 启动标准 SSE 流式解析器')
  const reader = response.body.getReader()
  const decoder = new TextDecoder('utf-8')
  let buffer = ''
  
  try {
    while (true) {
      const { done, value } = await reader.read()
      
      if (done) {
        console.log('✅ [SSE] 流式响应完成')
        if (onComplete) onComplete()
        break
      }
      
      // 解码新数据并添加到缓冲区
      buffer += decoder.decode(value, { stream: true })
      
      // 按 \n\n 分割 SSE 消息块（标准 SSE 格式）
      const chunks = buffer.split('\n\n')
      buffer = chunks.pop() || '' // 保留最后一个不完整的块
      
      for (const chunk of chunks) {
        if (chunk.trim() === '') continue
        
        // 处理每个 SSE 消息块中的行
        const lines = chunk.split('\n')
        for (const line of lines) {
          if (line.startsWith('data: ')) {
            const jsonStr = line.slice(6).trim()
            
            // 检查是否为结束标记
            if (jsonStr === '[DONE]') {
              console.log('🏁 [SSE] 收到结束标记 [DONE]')
              if (onComplete) onComplete()
              return
            }
            
            try {
              const data = JSON.parse(jsonStr)
              console.log('📨 [SSE] 解析消息:', data.type, data.content?.substring(0, 50))
              
              // 🔥 实时传递解析后的数据给前端
              if (onMessage) {
                onMessage(data)
              }
            } catch (err) {
              console.error('❌ [SSE] JSON 解析失败:', err, 'Raw data:', jsonStr)
            }
          }
        }
      }
    }
  } catch (error) {
    console.error('💥 [SSE] 流式响应处理错误:', error)
    if (onError) onError(error)
  }
}

// API方法
export default {
  // 用户注册
  register(username, email, password) {
    console.log('📝 [API] 调用注册接口:', { username, email })
    return api.post('/auth/register', {
      username,
      email,
      password
    })
  },

  // 用户登录
  login(credentials) {
    console.log('🔐 [API] 调用登录接口:', { email: credentials.email })
    return api.post('/auth/login', {
      email: credentials.email,
      password: credentials.password
    })
  },

  // 修改密码
  changePassword(passwordData) {
    console.log('🔑 [API] 调用修改密码接口')
    return api.post('/auth/change-password', passwordData)
  },

  // 刷新token
  refreshToken(refreshToken) {
    console.log('🔄 [API] 调用刷新Token接口')
    return api.post(`/auth/refresh?refresh_token=${refreshToken}`)
  },

  // 验证token
  validateToken() {
    console.log('🔍 [API] 调用Token验证接口')
    return api.post('/auth/validate')
  },

  // 用户登出
  logout() {
    console.log('🚪 [API] 调用登出接口')
    return api.post('/auth/logout')
  },

  // 获取当前用户信息
  getCurrentUser() {
    console.log('👤 [API] 调用获取用户信息接口')
    return api.get('/auth/me')
  },

  // ReAct 流式聊天 - 支持思考过程的实时流式输出
  async streamChat(message, conversationId = null, userId = null) {
    console.log('🧠 [API] 调用ReAct流式聊天接口:', { message, conversationId, userId })

    // 获取token - 优先从 Pinia store 获取，然后从 Cookie
    let token = null

    // 尝试从 Pinia store 获取 token
    try {
      const piniaUserData = localStorage.getItem('pinia-user')
      if (piniaUserData) {
        const userData = JSON.parse(piniaUserData)
        token = userData.token
        console.log('🔑 [API] streamChat从Pinia获取Token')
      }
    } catch (error) {
      console.log('⚠️ [API] streamChat Pinia Token获取失败，尝试Cookie')
    }

    // 如果 Pinia 中没有，尝试从 Cookie 获取
    if (!token) {
      token = getCookie('token')
      if (token) {
        console.log('🔑 [API] streamChat从Cookie获取Token')
      }
    }

    if (!token) {
      console.error('❌ [API] streamChat未找到认证Token')
      throw new Error('未找到认证Token，请重新登录')
    }

    console.log('✅ [API] streamChat已获取Token，准备发送请求')

    const response = await fetch('http://localhost:8002/api/react-stream', {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'Authorization': `Bearer ${token}`
      },
      body: JSON.stringify({
        message: message,
        conversation_id: conversationId,
        user_id: userId,
        include_history: true,
        max_history: 10
      })
    })

    if (!response.ok) {
      console.error('❌ [API] streamChat请求失败:', response.status, response.statusText)
      throw new Error(`HTTP error! status: ${response.status}`)
    }

    console.log('✅ [API] streamChat请求成功')
    return response // 直接返回response对象，让调用方处理流式响应
  },

  // 处理ReAct流式响应的辅助方法
  async handleReactStream(response, callbacks = {}) {
    console.log('🌊 [API] 开始处理ReAct流式响应')

    const {
      onStart = () => {},
      onUserMessage = () => {},
      onReactStart = () => {},
      onIterationStart = () => {},
      onThinking = () => {},
      onActionPlan = () => {},
      onActionResult = () => {},
      onContent = () => {},
      onComplete = () => {},
      onError = () => {}
    } = callbacks

    try {
      await handleStreamResponse(
        response,
        (data) => {
          console.log('📨 [ReAct] 收到流式数据:', data.type, data)

          switch (data.type) {
            case 'start':
              onStart(data)
              break
            case 'user_message':
              onUserMessage(data)
              break
            case 'react_start':
              onReactStart(data)
              break
            case 'iteration_start':
              onIterationStart(data)
              break
            case 'thinking_chunk':
              onThinking(data)
              break
            case 'action_plan':
              onActionPlan(data)
              break
            case 'action_result':
              onActionResult(data)
              break
            case 'content':
              onContent(data)
              break
            case 'complete':
              onComplete(data)
              break
            case 'error':
              onError(data)
              break
            default:
              console.log('🤔 [ReAct] 未知数据类型:', data.type)
          }
        },
        () => {
          console.log('✅ [ReAct] 流式响应完成')
        },
        (error) => {
          console.error('❌ [ReAct] 流式响应错误:', error)
          onError({ type: 'error', message: error.message })
        }
      )
    } catch (error) {
      console.error('💥 [ReAct] 处理流式响应异常:', error)
      onError({ type: 'error', message: error.message })
    }
  },

  // 创建新对话
  async createConversation() {
    console.log('🆕 [API] 创建新对话')
    // 新对话通过发送第一条消息来创建，这里返回一个模拟的对话对象
    // 实际的对话会在第一次发送消息时由后端创建
    const newConversation = {
      conversation_id: `temp_${Date.now()}`, // 临时ID，实际ID会在发送消息后更新
      title: '新对话',
      created_at: new Date().toISOString(),
      updated_at: new Date().toISOString()
    }
    return {
      success: true,
      data: newConversation
    }
  },

  // 获取对话列表
  getConversations() {
    console.log('📚 [API] 调用获取对话列表接口')
    return api.get('/conversations/')
  },

  // 获取对话消息
  getMessages(conversationId) {
    console.log('💬 [API] 调用获取消息接口，对话ID:', conversationId)
    return api.get(`/conversations/${conversationId}/messages`)
  },

  // 删除对话
  deleteConversation(conversationId) {
    console.log('🗑️ [API] 调用删除对话接口，对话ID:', conversationId)
    return api.delete(`/conversations/${conversationId}`)
  },

  // 更新对话标题
  updateConversationTitle(conversationId, title) {
    console.log('✏️ [API] 调用更新对话标题接口:', { conversationId, title })
    return api.patch(`/conversations/${conversationId}`, {
      title: title
    })
  },

  // 更新消息反馈
  updateMessageFeedback(messageId, feedback) {
    console.log('👍 [API] 调用更新消息反馈接口:', { messageId, feedback })
    return api.patch(`/conversations/messages/${messageId}/feedback`, {
      feedback: feedback
    })
  },

  // 获取用户情绪画像
  getUserEmotionProfile() {
    console.log('😊 [API] 调用获取用户情绪画像接口')
    return api.get('/user/emotion-profile')
  },

  // 获取用户情绪统计
  getUserEmotionStats() {
    console.log('📊 [API] 调用获取用户情绪统计接口')
    return api.get('/user/emotion-stats')
  },

  // 获取消息的思考过程
  getThinkingProcess(messageId) {
    console.log('🧠 [API] 调用获取思考过程接口:', { messageId })
    return api.post('/react-stream/thinking-process', {
      message_id: messageId
    })
  },

  // 获取对话的所有消息及思考过程
  getConversationMessagesWithThinking(conversationId) {
    console.log('💭 [API] 调用获取对话消息和思考过程接口:', { conversationId })
    return api.get(`/react-stream/conversation/${conversationId}/messages-with-thinking`)
  }
}